/*
 * $Id: DefaultContentTypeHandlerManager.java 676195 2008-07-12 15:55:58Z mrdon $
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package code.lucamarrocco.struts2.rest;

import static javax.servlet.http.HttpServletResponse.SC_NOT_MODIFIED;
import static javax.servlet.http.HttpServletResponse.SC_OK;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.struts2.ServletActionContext;

import com.opensymphony.xwork2.ModelDriven;
import com.opensymphony.xwork2.config.entities.ActionConfig;
import com.opensymphony.xwork2.inject.Container;
import com.opensymphony.xwork2.inject.Inject;

/**
 * Manages {@link ContentTypeHandler} instances and uses them to process results
 */
public class DefaultContentTypeHandlerManager implements ContentTypeHandlerManager {

	/** ContentTypeHandlers keyed by the extension */
	Map<String, ContentTypeHandler> handlersByExtension = new HashMap<String, ContentTypeHandler>();
	/** ContentTypeHandlers keyed by the content-type */
	Map<String, ContentTypeHandler> handlersByContentType = new HashMap<String, ContentTypeHandler>();

	String defaultExtension;

	@Inject("struts.rest.defaultExtension")
	public void setDefaultExtension(String name) {
		this.defaultExtension = name;
	}

	@Inject
	public void setContainer(Container container) {
		Set<String> names = container.getInstanceNames(ContentTypeHandler.class);
		for (String name : names) {
			ContentTypeHandler handler = container.getInstance(ContentTypeHandler.class, name);

			if (handler.getExtension() != null) {
				// Check for overriding handlers for the current extension
				String overrideName = container.getInstance(String.class, STRUTS_REST_HANDLER_OVERRIDE_PREFIX + handler.getExtension());
				if (overrideName != null) {
					if (!handlersByExtension.containsKey(handler.getExtension())) {
						handler = container.getInstance(ContentTypeHandler.class, overrideName);
					} else {
						// overriding handler has already been registered
						continue;
					}
				}
				this.handlersByExtension.put(handler.getExtension(), handler);
			}

			if (handler.getContentType() != null) {
				this.handlersByContentType.put(handler.getContentType(), handler);
			}
		}
	}

	/**
	 * Gets the handler for the request by looking at the request content type and extension
	 * 
	 * @param req
	 *            The request
	 * @return The appropriate handler
	 */
	public ContentTypeHandler getHandlerForRequest(HttpServletRequest req) {
		ContentTypeHandler handler = null;
		String contentType = req.getContentType();
		if (contentType != null) {
			handler = handlersByContentType.get(contentType);
		}
		if (handler == null) {
			String extension = findExtension(req.getRequestURI());
			if (extension == null) {
				extension = defaultExtension;
			}
			handler = handlersByExtension.get(extension);
		}
		return handler;
	}

	/**
	 * Gets the handler for the response by looking at the extension of the request
	 * 
	 * @param req
	 *            The request
	 * @return The appropriate handler
	 */
	public ContentTypeHandler getHandlerForResponse(HttpServletRequest req, HttpServletResponse res) {
		String extension = findExtension(req.getRequestURI());
		if (extension == null) {
			extension = defaultExtension;
		}
		ContentTypeHandler handler = handlersByExtension.get(extension);
		if (handler == null) return handlersByExtension.get(defaultExtension);
		return handler;
	}

	/**
	 * Handles the result using handlers to generate content type-specific content
	 * 
	 * @param actionConfig
	 *            The action config for the current request
	 * @param methodResult
	 *            The object returned from the action method
	 * @param target
	 *            The object to return, usually the action object
	 * @return The new result code to process
	 * @throws IOException
	 *             If unable to write to the response
	 */
	public String handleResult(ActionConfig actionConfig, Object methodResult, Object target) throws IOException {
		String resultCode = null;
		HttpServletRequest req = ServletActionContext.getRequest();
		HttpServletResponse res = ServletActionContext.getResponse();
		if (target instanceof ModelDriven) {
			target = ((ModelDriven) target).getModel();
		}

		boolean statusNotOk = false;
		if (methodResult instanceof HttpHeaders) {
			HttpHeaders info = (HttpHeaders) methodResult;
			resultCode = info.apply(req, res, target);
			if (info.getStatus() != SC_OK) {

				// Don't return content on a not modified
				if (info.getStatus() == SC_NOT_MODIFIED) {
					target = null;
				} else {
					statusNotOk = true;
				}

			}
		} else {
			resultCode = (String) methodResult;
		}

		// Don't return any content for PUT, DELETE, and POST where there are no errors
		if (!statusNotOk && !"get".equalsIgnoreCase(req.getMethod())) {
			target = null;
		}

		ContentTypeHandler handler = getHandlerForResponse(req, res);
		if (handler != null) {
			String extCode = resultCode + "-" + handler.getExtension();
			if (actionConfig.getResults().get(extCode) != null) {
				resultCode = extCode;
			} else {
				PrintWriter writer = res.getWriter();
				resultCode = handler.fromObject(target, resultCode, writer);
				res.setContentType(handler.getContentType());
				writer.close();
//				String text = writer.toString();
//				if (text.length() > 0) {
//					byte[] data = text.getBytes("UTF-8");
//					res.setContentLength(data.length);
//					res.setContentType(handler.getContentType());
//					res.getOutputStream().write(data);
//					res.getOutputStream().close();
//				}
			}
		}
		return resultCode;

	}

	/**
	 * Finds the extension in the url
	 * 
	 * @param url
	 *            The url
	 * @return The extension
	 */
	protected String findExtension(String url) {
		int dotPos = url.lastIndexOf('.');
		int slashPos = url.lastIndexOf('/');
		if (dotPos > slashPos && dotPos > -1) {
			return url.substring(dotPos + 1);
		}
		return null;
	}
}
